package com.heima.arrayList01;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.CopyOnWriteArraySet;

/**
    面试题：
        讲一下Java中集合的failFast和unSafe机制。
    1. FailFast机制：
        a. FailFast指的是一边基于迭代器遍历集合，一边修改集合的长度，
            这时候集合会抛出一个并发修改异常（ConcurrentModificationException），让操作快速失败！
        b. 本质是因为在集合源码底层有一个校验：比较 if(expectedModCount !=  ModCount)，
            如果不一致，就会throw ConcurrentModificationException()
            expectedModCount: 预期修改次数
            ModCount: 实际修改次数
        c. 针对 ArrayList，LinkedList，HashSet,HashMap等常用集合不适用于并发编程。

    2. unSafe机制：
        a. 在多线程并发访问时，一边修改集合长度，一遍遍历读取集合内容操作被允许，但是可能会导致读到的数据不安全。
        b. 实现原理：因为迭代器遍历访问的是snapshot数组，而list.add方法每次添加数据前会 Arrays.copyOf操作，产生一个
            newElements新的对象数据，从而实现数据的隔离，从而保证数据可用性。

    Vector是failFast还是unsafe呢？

 */

public class Demo {
    public static void main(String[] args) {

        ArrayList<String>list = new ArrayList<>();
//        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

//        HashSet<String> list = new HashSet<>();
//        CopyOnWriteArraySet list = new CopyOnWriteArraySet();

//        HashMap<String,String> map  = new HashMap<>();
        ConcurrentHashMap concurrentHashMap = new ConcurrentHashMap();

        list.add("hello");
        list.add("world");
        list.add("java");
        list.add("web");

        Iterator<String> it = list.iterator();
        while (it.hasNext()){
            String s = it.next();

            if (s.equals("world")){
                list.add("SE");
            }

            System.out.println("s = " + s);
        }

        System.out.println("list = " + list);
    }
}
